Modern C++ Tutorial: The Evolution of C++ Arrays

The transition from C-style arrays to std::array represents a fundamental shift toward type safety and generic programming in Modern C++.

1. The Pointer Decay Problem

Legacy arrays (int arr[N]) suffer from "pointer decay." When passed to functions, they lose their size metadata and convert to a raw pointer (int*). This leads to unsafe pointer arithmetic and buffer overflows.

2. The C++11 Modernization

std::array provides a thin, zero-overhead wrapper around raw arrays. It integrates with the STL (Standard Template Library) while respecting the Rule of Five.

3. Perfect Forwarding with std::forward

C++11 introduced std::forward to ensure std::array objects move through template wrappers without redundant copies. By leveraging Reference Collapsing Rules, we preserve the object's value category (lvalue vs rvalue).

$$T\&\& + \& \rightarrow T\&$$

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

What is the primary risk of 'pointer decay' in C-style arrays?

The array elements are deleted from memory.

The array loses its size and type metadata upon function entry.

The array is automatically moved to the heap.

The compiler adds padding to the array.

QUESTION 2

Which header must be included to use std::array?

✅ Correct!

The <array> header defines the template class for fixed-size sequences.

❌ Incorrect

Check your includes; std::array is distinct from the dynamic std::vector.

QUESTION 3

What is the purpose of std::forward when used with std::array?

To sort the array in ascending order.

To preserve the value category (lvalue/rvalue) when passing it through templates.

To convert the array into a pointer.

To dynamically resize the array at runtime.

❌ Incorrect

std::forward is about value-category preservation, not sorting or resizing.

QUESTION 4

How does std::array differ from std::vector regarding memory?

std::array is stored on the heap; std::vector on the stack.

std::array size is fixed at compile-time; std::vector can grow at runtime.

std::array has higher overhead than std::vector.

std::array uses pointers; std::vector does not.

✅ Correct!

std::array is stack-allocated with a fixed size, making it faster and more deterministic.

❌ Incorrect

std::vector is the one that manages dynamic heap memory.

QUESTION 5

According to Reference Collapsing, what is the result of T&& + &?

T&&

T&

Compiler Error

T*

Case Study: Graphics Engine Optimization

Modernizing Vertex Management

A legacy engine passes vertex data as `float* points, int size`. You are tasked with refactoring this to use C++11 `std::array` and a template-based factory that uses perfect forwarding to minimize latency.

Why is `std::array<float, 3>` safer than `float*` for a 3D coordinate?

Solution:
It encapsulates the size in the type signature, preventing out-of-bounds access and ensuring the function receives exactly 3 coordinates without needing a separate size parameter.

How does `std::forward` benefit a factory function creating these arrays?

Solution:
It allows the factory to move temporary arrays (rvalues) into storage rather than copying them, which is critical for performance in high-frequency graphics loops.

If you pass a named `std::array` into `relay(T&& arr)`, what does `T` resolve to?

Solution:
It resolves to an lvalue reference (T&) due to reference collapsing rules, because named variables are lvalues.